/**
 * 自定义数据存储管理工具
 * 用于管理页面标题、服务菜单和点位分类的自定义配置
 */

const STORAGE_KEYS = {
  CUSTOM_TITLE: 'custom_title',
  CUSTOM_BANNER: 'custom_banner',
  CUSTOM_QRCODE: 'custom_qrcode',
  CUSTOM_SERVICE_ORDER: 'custom_service_order',
  CUSTOM_CATEGORY_ORDER: 'custom_category_order',
  DATA_VERSION: 'data_version',
}

/**
 * 安全的localStorage操作包装器
 */
const safeLocalStorage = {
  getItem(key) {
    try {
      return localStorage.getItem(key)
    } catch (error) {
      console.error('localStorage.getItem失败:', key, error)
      return null
    }
  },
  setItem(key, value) {
    try {
      localStorage.setItem(key, value)
      return true
    } catch (error) {
      console.error('localStorage.setItem失败:', key, error)
      return false
    }
  },
  removeItem(key) {
    try {
      localStorage.removeItem(key)
      return true
    } catch (error) {
      console.error('localStorage.removeItem失败:', key, error)
      return false
    }
  },
}

/**
 * 生成数据版本号
 * @param {Array} services 服务菜单数据
 * @param {Array} categories 分类数据
 * @returns {string} 版本号
 */
function generateDataVersion(services, categories) {
  // 确保数组存在且不为空
  if (!services || !categories || services.length === 0 || categories.length === 0) {
    return ''
  }

  const serviceIds = services
    .map((s) => s.id)
    .filter((id) => id !== undefined && id !== null)
    .sort()
    .join(',')
  const categoryIds = categories
    .map((c) => c.id)
    .filter((id) => id !== undefined && id !== null)
    .sort()
    .join(',')

  if (!serviceIds || !categoryIds) {
    return ''
  }

  return btoa(`${serviceIds}|${categoryIds}`)
}

/**
 * 检查数据是否有更新
 * @param {Array} services 最新的服务菜单数据
 * @param {Array} categories 最新的分类数据
 * @returns {boolean} 是否有更新
 */
export function checkDataUpdate(services, categories) {
  try {
    const currentVersion = generateDataVersion(services, categories)
    const storedVersion = safeLocalStorage.getItem(STORAGE_KEYS.DATA_VERSION)

    // 如果当前版本为空，说明数据还没有准备好，不进行检查
    if (!currentVersion) {
      return false
    }

    // 如果没有存储的版本，说明是第一次，不算更新
    if (!storedVersion) {
      return false
    }

    return currentVersion !== storedVersion
  } catch (error) {
    console.error('检查数据更新失败:', error)
    // localStorage异常时，返回false避免清除配置
    return false
  }
}

/**
 * 更新数据版本号
 * @param {Array} services 服务菜单数据
 * @param {Array} categories 分类数据
 */
export function updateDataVersion(services, categories) {
  const version = generateDataVersion(services, categories)
  safeLocalStorage.setItem(STORAGE_KEYS.DATA_VERSION, version)
}

/**
 * 获取自定义标题
 * @param {string} defaultTitle 默认标题
 * @returns {string} 自定义标题或默认标题
 */
export function getCustomTitle(defaultTitle = '椒江区人才社区地图') {
  return safeLocalStorage.getItem(STORAGE_KEYS.CUSTOM_TITLE) || defaultTitle
}

/**
 * 设置自定义标题
 * @param {string} title 标题
 */
export function setCustomTitle(title) {
  safeLocalStorage.setItem(STORAGE_KEYS.CUSTOM_TITLE, title)
}

/**
 * 获取自定义Banner
 * @param {string} defaultBanner 默认Banner URL
 * @returns {string} 自定义Banner URL或默认Banner URL
 */
export function getCustomBanner(defaultBanner = '') {
  return safeLocalStorage.getItem(STORAGE_KEYS.CUSTOM_BANNER) || defaultBanner
}

/**
 * 设置自定义Banner
 * @param {string} bannerUrl Banner URL
 */
export function setCustomBanner(bannerUrl) {
  safeLocalStorage.setItem(STORAGE_KEYS.CUSTOM_BANNER, bannerUrl)
}

/**
 * 获取自定义二维码
 * @param {string} defaultQrcode 默认二维码 URL
 * @returns {string} 自定义二维码 URL或默认二维码 URL
 */
export function getCustomQrcode(defaultQrcode = '') {
  return safeLocalStorage.getItem(STORAGE_KEYS.CUSTOM_QRCODE) || defaultQrcode
}

/**
 * 设置自定义二维码
 * @param {string} qrcodeUrl 二维码 URL
 */
export function setCustomQrcode(qrcodeUrl) {
  safeLocalStorage.setItem(STORAGE_KEYS.CUSTOM_QRCODE, qrcodeUrl)
}

/**
 * 获取自定义服务菜单顺序
 * @param {Array} originalServices 原始服务菜单数据
 * @returns {Array} 排序后的服务菜单数据
 */
export function getCustomServiceOrder(originalServices) {
  try {
    const storedOrder = safeLocalStorage.getItem(STORAGE_KEYS.CUSTOM_SERVICE_ORDER)
    if (!storedOrder) return originalServices

    const orderIds = JSON.parse(storedOrder)
    const servicesMap = new Map(originalServices.map((s) => [s.id, s]))

    // 按存储的顺序排列
    const orderedServices = []
    orderIds.forEach((id) => {
      if (servicesMap.has(id)) {
        orderedServices.push(servicesMap.get(id))
        servicesMap.delete(id)
      }
    })

    // 添加新增的服务（如果有的话）
    orderedServices.push(...servicesMap.values())

    return orderedServices
  } catch (error) {
    console.error('获取自定义服务顺序失败:', error)
    return originalServices
  }
}

/**
 * 设置自定义服务菜单顺序
 * @param {Array} serviceIds 服务ID数组
 */
export function setCustomServiceOrder(serviceIds) {
  safeLocalStorage.setItem(STORAGE_KEYS.CUSTOM_SERVICE_ORDER, JSON.stringify(serviceIds))
}

/**
 * 获取自定义分类顺序
 * @param {Array} originalCategories 原始分类数据
 * @returns {Array} 排序后的分类数据
 */
export function getCustomCategoryOrder(originalCategories) {
  try {
    const storedOrder = safeLocalStorage.getItem(STORAGE_KEYS.CUSTOM_CATEGORY_ORDER)
    if (!storedOrder) return originalCategories

    const orderIds = JSON.parse(storedOrder)
    const categoriesMap = new Map(originalCategories.map((c) => [c.id, c]))

    // 按存储的顺序排列
    const orderedCategories = []
    orderIds.forEach((id) => {
      if (categoriesMap.has(id)) {
        orderedCategories.push(categoriesMap.get(id))
        categoriesMap.delete(id)
      }
    })

    // 添加新增的分类（如果有的话）
    orderedCategories.push(...categoriesMap.values())

    return orderedCategories
  } catch (error) {
    console.error('获取自定义分类顺序失败:', error)
    return originalCategories
  }
}

/**
 * 设置自定义分类顺序
 * @param {Array} categoryIds 分类ID数组
 */
export function setCustomCategoryOrder(categoryIds) {
  safeLocalStorage.setItem(STORAGE_KEYS.CUSTOM_CATEGORY_ORDER, JSON.stringify(categoryIds))
}

/**
 * 清除所有自定义配置
 */
export function clearAllCustomConfig() {
  Object.values(STORAGE_KEYS).forEach((key) => {
    safeLocalStorage.removeItem(key)
  })
}

/**
 * 重置过期的自定义配置
 * @param {Array} services 最新的服务菜单数据
 * @param {Array} categories 最新的分类数据
 */
export function resetOutdatedConfig(services, categories) {
  // 确保两个数组都不为空才进行检查
  if (!services || !categories || services.length === 0 || categories.length === 0) {
    return
  }

  if (checkDataUpdate(services, categories)) {
    // 清除过期的排序配置，保留标题配置
    safeLocalStorage.removeItem(STORAGE_KEYS.CUSTOM_SERVICE_ORDER)
    safeLocalStorage.removeItem(STORAGE_KEYS.CUSTOM_CATEGORY_ORDER)
    updateDataVersion(services, categories)
    console.log('检测到数据更新，已重置排序配置')
  }
}
